重走Java基础之Streams 二

重走Java基础之Streams 二

接上篇重走Java基础之Streams(一)/)

Processing Order

Stream对象的处理可以是顺序或并行.

sequential 模式中,按照“Stream”的源的顺序处理元素。 如果Stream是有序的(例如SortedMap 实现或List ),处理过程保证匹配源的排序。 然而,在其他情况下,应注意不要依赖于顺序(参见:是Java的HashMap``keySet()迭代顺序一致?)。

Example:

1
2
3
4
5
6
7
List<Integer> integerList = Arrays.asList(0, 1, 2, 3, 42); 

// sequential
long howManyOddNumbers = integerList.stream()
.filter(e -> (e % 2) == 1).count();

System.out.println(howManyOddNumbers); // Output: 2

Live on Ideone

Parallel(并行)模式允许在多个核上使用多个线程,但不能保证处理元素的顺序。

如果在顺序的Stream上调用多个方法,则不必调用每个方法。 例如,如果一个Stream被过滤,并且元素的数量减少到一,则不会发生对诸如sort的方法的后续调用。 这可以提高顺序的Stream的性能 - 这是一个并行的Stream不可能实现的优化。
Example:

1
2
3
4
5
// parallel
long howManyOddNumbersParallel = integerList.parallelStream()
.filter(e -> (e % 2) == 1).count();

System.out.println(howManyOddNumbersParallel); // Output: 2

Live on Ideone


Differences from Containers (or Collections)

虽然一些操作可以在Containers和Streams上执行,但它们最终用于不同的目的并支持不同的操作。 容器更注重元素的存储方式以及如何有效地访问这些元素。 另一方面,Stream不提供对其元素的直接访问和操纵; 它更专用于作为集体实体的对象组并且作为整体对该实体执行操作。 StreamCollection是用于这些不同目的的单独的高级抽象。

Consuming Streams

A Stream将仅在有终端操作时被遍历,如 count()collect()forEach()。否则,不会对Stream 执行任何操作。

在下面的示例中,没有将终端操作添加到Stream,因此 filter() 操作不会调用,并且不会产生输出,因为peek()不是终端操作

1
IntStream.range(1, 10).filter(a -> a % 2 == 0).peek(System.out::println);

Live on Ideone

这是一个具有有效终端操作Stream 序列,因此产生一个输出。

你也可以使用forEach而不是peek

1
IntStream.range(1, 10).filter(a -> a % 2 == 0).forEach(System.out::println);

Live on Ideone

Output:

2
4
6
8

在执行终端操作之后, Stream 被执行消耗,不能被重复使用。


一般来说,Stream的操作如下图所示:

Stream Operation

NOTE: 即使没有终端操作,也始终执行参数检查

1
2
3
4
5
try {
IntStream.range(1, 10).filter(null);
} catch (NullPointerException e) {
System.out.println("We got a NullPointerException as null was passed as an argument to filter()");
}

Live on Ideone

Output:

We got a NullPointerException as null was passed as an argument to filter()

Creating a Frequency Map

groupingBy(classifier,downstream)collector允许将Stream元素集合通过对组中的每个元素进行分类到一个Map,并对分类在同一组中的元素执行后续操作。

这个原则的一个典型例子是使用Map 来计算Stream。在这个例子中,分类器是简单的identity函数,它返回元素as-is。后续操作计算等于元素的数量,使用counting()

1
2
3
4
Stream.of("apple", "orange", "banana", "apple")
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
.entrySet()
.forEach(System.out::println);

后续操作本身是一个收集器(Collectors.counting() ),对String类型的元素进行操作,并生成类型为Long的结果。 collect方法调用的结果是一个Map

This would produce the following output:

banana=1
orange=1
apple=2

Infinite Streams 无限流

可以生成一个不结束的Stream。 在无限的Stream上调用终端方法导致Stream进入无限循环。 一个Streamlimit方法可以用于 限制Java处理的Stream的术语数。

这个例子生成一个所有自然数的Stream,从数字1开始。Stream的每个连续项比上一个高一个。 通过调用这个Stream的limit方法,只有Stream的前5个项被考虑和打印。

1
2
3
4
5
// Generate infinite stream - 1, 2, 3, 4, 5, 6, 7, ...
IntStream naturalNumbers = IntStream.iterate(1, x -> x + 1);

// Print out only the first 5 terms
naturalNumbers.limit(5).forEach(System.out::println);

Output:

1
2
3
4
5

Collect Elements of a Stream into a Collection 将流的元素收集到集合中

Collect with toList() and toSet()

通过Stream.collect操作可以轻松地将Stream元素收集到容器中 :

1
2
3
4
5
6
7
System.out.println(Arrays
.asList("apple", "banana", "pear", "kiwi", "orange")
.stream()
.filter(s -> s.contains("a"))
.collect(Collectors.toList())
);
// prints: [apple, banana, pear, orange]

其他集合实例,例如Set,可以通过使用其他Collectors 内置方法。 例如,Collectors.toSet()收集 Stream into到一个 Set中。


Explicit(显式) control over the implementation of List or Set

根据Collectors#toList()Collectors#toSet()文档,不能保证所返回ListSet的类型,可变性, 序列化或线程安全。

为了显式控制要返回的实现,可以使用Collectors#toCollection(Supplier),从而可以返回一个指定类型的新的空集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
// syntax with method reference
System.out.println(strings
.stream()
.filter(s -> s != null && s.length() <= 3)
.collect(Collectors.toCollection(ArrayList::new))
);

// syntax with lambda
System.out.println(strings
.stream()
.filter(s -> s != null && s.length() <= 3)
.collect(Collectors.toCollection(() -> new LinkedHashSet<>()))
);

Parallel Stream

Note: 在决定使用哪个Stream之前,请先看看ParallelStream vs Sequential Stream的对比.

当你想同时并发执行Stream操作时,你可以使用这些方法。

1
2
List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");
Stream<String> aParallelStream = data.stream().parallel();

Or:

1
Stream<String> aParallelStream = data.parallelStream();

要执行为并行流定义的操作,请调用终端运算符:

1
aParallelStream.forEach(System.out::println);

(A possible) output from the parallel Stream:

Three
Four
One
Two
Five

顺序可能会改变,因为所有的元素被并行处理(这个可能使它更快)。当顺序无关紧要时使用parallelStream

性能影响

在涉及网络的情况下,并行的 Stream可以降低应用的整体性能,因为所有并行的 Stream对于网络使用公共的fork-join线程池。

另一方面,在许多其他情况下,根据当前运行的CPU中可用内核的数量,并行的 Stream可以显着提高性能。

您的支持将鼓励我继续创作!